The present invention relates in general to object-oriented computer systems. More specifically, the present invention relates to a method and system for moving objects between heterogeneous execution environments of object-oriented computer systems.
Current computer programming techniques include the use of Object-Oriented Programming (xe2x80x9cOOPxe2x80x9d). Object-Oriented Programming centers on reusable, self-contained, callable program code modules known in the art as xe2x80x9cobjects.xe2x80x9d Such a modular approach makes software development more efficient and reliable through the use and reuse of proven, tested objects.
Each object is designed to accomplish a predefined set of operations through xe2x80x9cmethodsxe2x80x9d (which are also referred to herein as xe2x80x9cfunctionsxe2x80x9d). These methods include programmed tasks for the object to perform when called upon to do so (i.e., invoked). Each particular method is defined within a xe2x80x9cclassxe2x80x9d associated with an object. The class acts as a template that describes the behaviour of a group of similar objects. An object is instantiated from (or is a runtime instance of) a selected class, and includes methods and attributes (or data) defined in the class.
Although object-oriented computer systems may include heterogeneous execution environments, several limitations apply thereto. For example, once an object is instantiated within a particular execution environment, it is bound to execution therein. Little or no conventional mechanism exists for moving the object between different heterogeneous execution environments at runtime.
Further, an object may include internal values and data that accumulate as the object is repeatedly invoked, and are referred to as the object""s xe2x80x9cstate.xe2x80x9d This state is bound to the particular instantiation of the object in the current execution environment. Therefore, an object is further bound to its particular instantiation in the current execution environment since conventional techniques do not permit the transfer of the objects xe2x80x9cstatexe2x80x9d between execution environments.
The present invention is directed toward solutions for the above noted problems.
In a first aspect, the present invention operates in a heterogeneous, object-oriented computer system that includes a first execution environment and a second execution environment. In particular, the first execution environment is different from the second execution environment.
The invention includes a method of managing an object at runtime and includes identifying, at runtime, the object executing within the first execution environment. The object performs a predefined function in the first execution environment; however, performing the predefined function using the second execution environment is desirable. Runtime usage of the object executing within the first execution environment is terminated, and the object is instantiated within the second execution environment. Accordingly, the object facilitates performance of the predefined function using the second execution environment.
As an enhancement, the object may have a state that includes at least one variable maintained between invocations of the object. The method may further includes maintaining the state of the object during the terminating and the instantiating. In particular, the maintaining may include saving the state of the object before terminating usage of the object within the first execution environment, and restoring the state of the object after instantiating the object within the second execution environment. The saving and the restoring of the state of the object may be performed by at least one function of the object. In one example, the computer system may include a state management object that manages saved states of objects. The at least one function of the object may then invoke the state management object during the saving and the restoring of the state of the object.
As a further enhancement, the saving and the restoring of the state of the object may include accessing, external to the object, at least one memory location corresponding to the at least one variable that the state of the object is contained within. In support of the foregoing, the method may include generating at least one memory map that indicates the at least one variable corresponding to the at least one memory location. The accessing may then include using the at least one memory map to determine the at least one memory location corresponding to the at least one variable that the state of the object is contained within.
The state of the object may include at least one variable data type. Further, the first execution environment may maintain the at least one variable data type in a first format, and the second execution environment may maintain the at least one variable data type in a second format. In view of the foregoing, and as yet another enhancement of the present invention, the method may include, after saving the state, converting the state from the first format to the second format to facilitate restoring the state to the second execution environment.
A system corresponding to the above-disclosed method is also presented herein.
The techniques of the present invention have many advantages and features associated therewith. Runtime adaptability and flexibility are facilitated by the ability to move objects between execution environments, despite the heterogeneity thereof. Thus, an object can be moved to a faster execution environment to increase its capacity, or it can be moved off a failing, or soon-to-be unavailable system, to preserve availability of the object. Furthermore, the disclosed techniques preserve the object""s state, when it is moved. This preservation is performed regardless of different variable formats that the execution environments the objects are moved between may have. Advantageously, the object has the benefit of its accumulated state information established when in the original execution environment, even when moved into another, heterogeneous execution environment. Thus, the techniques of the present invention advance the art of runtime object management in object-oriented computer systems.